{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split,cross_val_score,KFold\n",
    "from sklearn.ensemble import GradientBoostingClassifier,RandomForestClassifier\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "train_df=pd.read_csv('./titanic/train.csv')\n",
    "test_df=pd.read_csv('./titanic/test.csv')\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#重复上一节的操作...\n",
    "train_df['Cabin'].fillna('missing',inplace=True)\n",
    "test_df['Cabin'].fillna('missing',inplace=True)\n",
    "train_df['Embarked'].fillna(train_df['Embarked'].mode()[0],inplace=True)\n",
    "train_df['Age'].fillna(train_df['Age'].mean(),inplace=True)\n",
    "test_df['Age'].fillna(train_df['Age'].mean(),inplace=True)\n",
    "test_df['Fare'].fillna(train_df['Fare'].mean(),inplace=True)\n",
    "import category_encoders as ce\n",
    "del train_df['Name']\n",
    "del train_df['Ticket']\n",
    "del test_df['Name']\n",
    "del test_df['Ticket']\n",
    "del train_df['PassengerId']\n",
    "del test_df['PassengerId']\n",
    "label=train_df[\"Survived\"]\n",
    "del train_df[\"Survived\"]\n",
    "# target \n",
    "target_encoder = ce.TargetEncoder(cols=['Embarked','Cabin']).fit(train_df,label)\n",
    "train_df=target_encoder.transform(train_df)\n",
    "test_df=target_encoder.transform(test_df)\n",
    "\n",
    "# one hot\n",
    "onehot_encoder = ce.OneHotEncoder(cols=['Sex']).fit(train_df)\n",
    "train_df=onehot_encoder.transform(train_df)\n",
    "test_df=onehot_encoder.transform(test_df)\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler,MinMaxScaler,Normalizer\n",
    "#z-score归一化为例\n",
    "standard_scaler=StandardScaler()\n",
    "standard_scaler.fit(train_df)\n",
    "new_train_df=pd.DataFrame(standard_scaler.transform(train_df),columns=train_df.columns)\n",
    "new_test_df=pd.DataFrame(standard_scaler.transform(test_df),columns=train_df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7785468194526353, 0.04490418481133087)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# base line...\n",
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier, new_train_df, label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 简介\n",
    "关于特征增强，可以考虑两个方向：   \n",
    "\n",
    "（1）增加有用的特征： \n",
    "\n",
    "    这个就有些黑科技了，更多的是通过业务常识去造特征；\n",
    "\n",
    "（2）去掉有害的特征，即**特征降维**，这又有两个方向：   \n",
    "\n",
    ">（2.1）从原始特征集中去掉部分特征，这部分技术通常称为**特征选择**；   \n",
    "\n",
    ">（2.2）将原始特征集映射为一个新的低维特征集，从而过滤掉高维空间中的噪声，这部分技术可以称为**特征变换**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 一.增加有用的特征 \n",
    "\n",
    "#### 1.1根据业务背景造特征\n",
    "\n",
    "这部分不具有通用性...就不写代码了...对于titanic这个数据集，可以考虑从Name中提取一些特征，比如Mrs可以放映出该乘客已经结婚，Miss表示未婚小姐姐等...另外SibSp表示乘客兄弟姐妹/配偶的个数，而Parch表示乘客父母/孩子的个数，可以简单相加表示他们的家庭成员多少，越多的存活率可能越高...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2添加聚类标签\n",
    "聚类标签可以看作是对目前样本的做的特征映射，将高维空间相似的特征映射到相同的标签；这里演示用kmean生成聚类标签，利用calinski_harabaz选择较优的k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'distortion degree')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3Xl4VPXZ//H3zSKKoCLgxqpUsFhRMFCsiGTccatSLdYiD/qACyouFRds1W4/waot2scKrlWqBUGrLVpQgmsBAVFEtO7KUhDbqhQVAvfvj++ZMoRJMgk5cyaZz+u6zjUzZ5s7Q5g7393cHRERkYoaJR2AiIgUJiUIERHJSglCRESyUoIQEZGslCBERCQrJQgREclKCUJERLJSghARkayUIEREJKsmSQewLdq0aeOdO3dOOgwRkXplwYIFa9y9bXXn1esE0blzZ+bPn590GCIi9YqZfZjLeapiEhGRrJQgREQkKyUIERHJSglCRESyUoIQEZGsiipBjBsHZWVb7isrC/tFRGRLRZUgeveG00/fnCTKysLr3r2TjUtEpBDV63EQNVVaCpMnw6BB0LUrvPtueF1amnRkIiKFp6hKEBCSwTHHwNy5cNxxSg4iIpUpugRRVgYzZ4IZTJ26dZuEiIgERZUg0m0OU6ZAnz6w995btkmIiMhmRZUgXn55c5tDKgVvvQX33x/2i4jIlooqQYwevbnNIZWC8nJo1CjsFxGRLRVVgsj0ne9A06Ywa1bSkYiIFKaiTRDNm8MhhyhBiIhUpmgTBIRqpoUL4V//SjoSEZHCU/QJwh2eey7pSERECk9sCcLMOphZmZktNbMlZjYq2n+Qmc0xs0VmNt/M+kT7zczGm9k7ZvaamfWKK7a0Pn1ghx1UzSQikk2cU22UA5e7+0IzawksMLOZwDjgBnd/0swGRq8HAMcB+0bbt4E7osfYNGsG/fopQYiIZBNbCcLdV7r7wuj5F8BSoB3gwE7RaTsDK6LnJwO/92AOsIuZ7RlXfGmpFLz+OqxeHfc7iYjUL3lpgzCzzkBPYC5wCXCTmX0M/Aq4OjqtHfBxxmXLon0V7zUiqpqa/8knn2xzbKlUeJw9e5tvJSLSoMSeIMysBTAVuMTdPwfOBy519w7ApcDd6VOzXO5b7XCf4O4l7l7Stm3bbY6vVy9o2VLVTCIiFcWaIMysKSE5THL3adHuoUD6+RSgT/R8GdAh4/L2bK5+ik2TJnD44UoQIiIVxdmLyQilg6XufkvGoRXA4dHzFPB29Pxx4KyoN1Nf4DN3XxlXfJlSKXj7bVi2LB/vJiJSP8TZi+lQYAiw2MwWRfuuAYYDvzGzJsBXwIjo2HRgIPAOsA4YFmNsW0i3Q5SVwZAh+XpXEZHCFluCcPcXyN6uAHBwlvMdGBlXPFU54ABo3TpUMylBiIgERT2SOq1RIxgwICQI36pZXESkOClBRFIp+OgjeO+9pCMRESkMShCRzHYIERFRgvivbt1gjz3U3VVEJE0JImIWShFqhxARCZQgMqRSsGoVLF2adCQiIslTgsigdggRkc2UIDLsvTd06qR2CBERUILYSioVShCbNiUdiYhIspQgKkilwhrVr76adCQiIslSgqigtDQ8qppJRIqdEkQF7dpB165qqBYRUYLIIpWCZ5+FDRuSjkREJDlKEFmkUrB2LSxYkHQkIiLJUYLIYsCA8Kh2CBEpZkoQWbRtG9aIUDuEiBQzJYhKpFLwwgvw9ddJRyIikgwliEqkUvDVVzBnTtKRiIgkQwmiEv37h5Xm1A4hIsVKCaISu+wCvXqpHUJEipcSRBVSqVDF9J//JB2JiEj+KUFUIZUKg+VefDHpSERE8k8JogqHHgpNmqgdQkSKkxJEFVq0gG9/W+0QIlKclCCqkUrB/Pnw2WdJRyIikl9KENVIpcLiQc89l3QkIiL5pQRRjb59oVkztUOISPFRgqjG9tuHxmq1Q4hIsVGCyEEqFZYgXbMm6UhERPJHCSIHqVR4nD070TBERPJKCSIHJSWw445qhxCR4qIEkYOmTcPkfWqHEJFiogSRo1QK3nwTVqxIOhIRkfyILUGYWQczKzOzpWa2xMxGZRy7yMzeivaPy9h/tZm9Ex07Jq7YaiPdDqFShIgUiyYx3rscuNzdF5pZS2CBmc0EdgdOBnq4+9dmthuAmXUHBgP7A3sBT5tZV3ffGGOMOTvwwDAF+KxZcOaZSUcjIhK/2EoQ7r7S3RdGz78AlgLtgPOBG9396+jY6uiSk4GH3f1rd38feAfoE1d8NdW4MQwYoBKEiBSPvLRBmFlnoCcwF+gKHGZmc83sWTPrHZ3WDvg447Jl0b6CkUrB+++HTUSkoYs9QZhZC2AqcIm7f06o1moF9AWuACabmQGW5XLPcr8RZjbfzOZ/8sknMUa+NbVDiEgxiTVBmFlTQnKY5O7Tot3LgGkezAM2AW2i/R0yLm8PbNVnyN0nuHuJu5e0bds2zvC30r077LabxkOISHHIKUGYWT8zGxY9b2tme+dwjQF3A0vd/ZaMQ48BqeicrsB2wBrgcWCwmTWL7r8vMK8mP0zczKC0NJQgfKuyjYhIw1JtgjCz64ArgaujXU2BB3O496HAECBlZouibSBwD7CPmb0OPAwMjUoTS4DJwBvAU8DIQunBlCmVCmMh/v73pCMREYlXLt1cTyE0MKd7JK2Iuq1Wyd1fIHu7AsAPK7nmF8AvcogpMel2iFmzoFu3ZGMREYlTLlVM693diRqMzWzHeEMqbF26QPv2aocQkYYvlwQx2czuBHYxs+HA08DEeMMqXGahFDF7dlhpTkSkoao2Qbj7r4BHCL2RugE/cffb4g6skKVSYW2I119POhIRkfjkOtXG3wF396fNrLmZtYxGRxel0tLwOGsW9OiRbCwiInHJpRfTcEIJ4s5oVztCV9Wi1bFjaItQO4SINGS5tEGMJHRZ/RzA3d8GdoszqPoglYJnn4Xy8qQjERGJRy4J4mt3X59+YWZNyDIFRrFJpeDzz+GVV5KOREQkHrkkiGfN7BpgBzM7CpgCPBFvWIVt3LiwyhxsrmYqKwv7RUQailwSxFXAJ8Bi4FxgOnBtnEEVut694bzzoFOnkCDKyuD008N+EZGGospeTGbWGLjf3X9IEY99qKi0FCZPhoEDYflyWLAApkzZ3LtJRKQhqLIEEc2F1NbMtstTPPVGaSn84Aehkbp9eyUHEWl4cqli+gB40cx+bGaXpbeY4yp4ZWXw+OPQrx+8+irccEPSEYmI1K1cEsQK4M/RuS0ztqKVbnOYPDm0QXTtGhLElClJRyYiUneqHUnt7vrbuIKXXw7JIV2t9PjjYUT1mDEwaBA0ystCriIi8ao2QZjZE2w97uEzYD5wp7t/FUdghWz06C1fd+sGv/41XHAB/Pa3cNFFycQlIlKXcvlb9z1gLaEX00TCiOpVQFfUs+m/zjsv9GoaPRqWLEk6GhGRbZfLZH093b1/xusnzOw5d+9vZvoqjJjBPffAAQfAD38Ic+fCdur7JSL1WC4liLZm1jH9InreJnq5PvslxWn33eGuu2DRIvjJT5KORkRk2+SSIC4HXjCzMjObDTwPXBGtLHd/nMHVRyedBMOHh2k3nn026WhERGrPwmqi1Zxk1gzYj7DG9JuF0jBdUlLi8+fPTzqMraxdCz17wvr1YYzELrskHZGIyGZmtsDdS6o7L5f1IJoDVwAXuvsioIOZnVAHMTZYLVrAgw+GaTguvDDpaEREaieXKqZ7CW0Nh0SvlwE/jy2iBuLb3w7tEJMmwcMPJx2NiEjN5ZIgurj7OGADgLt/Sahqkmpccw307Qvnnw8ff5x0NCIiNZNLglhvZjsQDZYzsy7A17FG1UA0aRKqmjZsgKFDYdOmpCMSEcldLgniOuApQtvDJOAZYHTVl0haly7wm9+E+ZtuvTXpaEREcpdrL6bWQF9C1dIcd18Td2C5KNReTBW5w6mnwvTpYR6nHj2SjkhEitk292Iys17pDegErCTM7Nox2ic5MoOJE2HXXeHMM+GrgugkLCJStaqm2rg5etweKAFeJZQgegBzgX7xhtawtGkD994Lxx0XGq9vuSXpiEREqlZpCcLdS929FPgQ6OXuJe5+MNATeCdfATYkxx4LI0eGtoinn046GhGRquXSSL2fuy9Ov3D314GD4gupYRs3DvbbL/Rq+uc/k45GRKRyuSSIpWZ2l5kNMLPDzWwisDTuwBqq5s3D4LnVq8MU4Tn0ERARSUQuCWIYsAQYBVwCvBHtk1rq1Qt+9rOwROmDDyYdjYhIdjl1cy1U9aWbazYbN8I3vgGrVsEbb0DnzmF/WVnoCltx1ToRkbpSZ5P1STwaN4Zf/jJ0eT3xxJAwysrg9NOhd++koxMRiTFBmFmHaA2JpWa2xMxGVTj+IzNzM2sTvTYzG29m75jZa8Uw1uKMM+DKK+H11+Goo0JymDwZSkuTjkxEJN4SRDlwubt/kzAKe6SZdYeQPICjgI8yzj8O2DfaRgB3xBhbwfjlL6F791B66NdPyUFECkcu60F0NbOJZjbDzGalt+quc/eV7r4wev4FoedTu+jwrYT5nDIbQE4Gfu/BHGAXM9uzpj9QfTN7dmiH6NQJHnsMrroq6YhERIKqRlKnTQF+B0wENtbmTcysM2GA3VwzOwlY7u6vmm0xa3g7IHNS7GXRvpUV7jWCUMKgY8eO1GfpNocpU8L6EYcdBmPHhllfx41LOjoRKXa5JIhyd691dY+ZtQCmErrIlgNjgKOznZpl31ZdrNx9AjABQi+m2sZVCF5+ecs2hxdegP794aabQg+nESOSjU9EilsuCeIJM7sAeJSMdSDcvdpxwGbWlJAcJrn7NDM7ANgbSJce2gMLzawPocTQIePy9oTJARusil1Zd9gBnn8eBg2Cc8+F8nK44IJkYhMRySVBDI0er8jY58A+VV1kIQPcDSx191sAoik7dss45wOgxN3XmNnjwIVm9jDwbeAzd1+59Z0btu23h2nT4LTTwrxN5eVw8cVJRyUixajaBOHue9fy3ocCQ4DFZrYo2neNu0+v5PzpwEDCRIDrKOLR2s2awSOPwODBMGpUSBKXXZZ0VCJSbKpNEFE10flA/2jXbOBOd99Q1XXu/gLVrF3t7p0znjswsrp4isV228Ef/wg/+AFcfnlIEhpdLSL5lEsV0x1AU+D/otdDon3/G1dQEjRtCg89FNa2vvLKsLb1mDFJRyUixSKXBNHb3Q/MeD3LzF6NKyDZUpMm8MAD4fHaa0NJ4rrrko5KRIpBLglio5l1cfd3AcxsH2o5HkJqp0kTuO++MH/T9deHeZtuuCEsZSoiEpdcEsQVQJmZvUdoU+hEETcgJ6VxY7jnnpAsfvazUN30y18qSYhIfHLpxfSMme0LdCMkiDfd/etqLpMYNGoEEyaEJHHjjaG6adw4JQkRiUelCcLMUu4+y8xOrXCoi5nh7tNijk2yaNQI7rgjJIlf/SokiVtuUZIQkbpXVQnicGAWcGKWYw4oQSTEDG67LSSJX/86JInx45UkRKRuVZog3D3dV+an7v5+5jEzq+3gOakjZnDrrSFJ3HwzfPhhmA22UTQ/r1amE5Ftlct6EFOz7HukrgORmjMLE/udcQY88URYmW7TJq1MJyJ1o6o2iP2A/YGdK7RD7ARsH3dgkhszmDQp9HJ68EHo0QP+8Y8whbgWHxKRbVFVG0Q34ARgF7Zsh/gCGB5nUFIzZmEw3fLlofSw446wejW4q11CRGqv0iomd/8TYTqNm919WMZ2sbu/lL8QJRdlZbB4Mfzv/8LXX4eJ/o4/Hj74IOnIRKS+qrINwt03EtaOlgKWbnOYPBkmToQnnwyliLIy2H//zd1hRURqIpdG6pfM7HYzO8zMeqW32COTnFVcme7II0Oj9aWXwhFHwBVXQEkJzJuXbJwiUr9YmGW7ihPMyrLsdndPxRNS7kpKSnz+/PlJh1HQ3OHRR+Gii2DlSrjwQvj5z2GnnZKOTESSYmYL3L2kuvOqLUG4e2mWLfHkILkxg1NPhTfeCMuX3n47dO8exkyIiFSl2gRhZjub2S1mNj/abjaznfMRnNSdnXcOyeGll6B1azjlFPjud+Hjj5OOTEQKVS5tEPcQuraeHm2fA/fGGZTEp29fmD8fxo6FGTNCaWL8+DCFuIhIplwSRBd3v87d34u2G4B94g5M4tO0aZiCY8kS6NcvrHvdt294LKvQ4lRWFmaMFZHik0uC+NLM+qVfmNmhwJfxhST5svfeMH16WNb0o49CFdTxx4d9oCk7RIpdLgniPOC3ZvaBmX0A3A6cG2tUkjdmYVDdm2/COefAl1+GOZ2+973NYys0ZYdIccolQXwerUndA+jh7j0JbRLSgLRqFRYjev552HVXmDo1JIuZM+G995KOTkSSkPNsru7+ubt/Hu3TbK4N1IYN4XHw4PD8xhuhSxc46qgwAeD69cnGJyL5o9lc5b8yp+woLQ2vv/c9OOkkmDUrHGvbFoYNC3M+7btv0hGLSJyqKkFUnM01vfVCs7k2SBWn7CgthUcegW9+M1QzPflk6PV0883QtSukUvDww2FywDiMG6deVSJJymWqjUPc/W95iqdGNNVGMlauhHvvhbvugvffDwPvhg6F4cNhv/3CF3jv3ls2btdmhbt0iWb8+FCKmTdPDecidSHXqTZySRDjgJ8TurY+BRwIXOLuD9ZFoNtCCSJZmzbBM8+Exu3HHgszxvbvH0oZEyZsWVVV8Yu9vBxWrYIVKyrfli+HTz8N55uFRZGOPz5Uex1yCOyzj9a7EKmNukwQi9z9IDM7BfgucClQFvVsSpQSROFYtQruvz8khnffhRYtwujsVCokiFQ0e1f6y3/VqjCRYKZGjWCPPWCvvcLWrl14nDMH/vIX6NwZ1qyBtWvD+W3bhkTRt2947N07THMuIlWrywSxxN33N7OJwFR3f8rMXlWCkGw2bYLZs0OimDIlvIbwZZ7+wq9s2223UErIlC59nH8+3HFHGNS3227wt7+Fbc4ceOutcG7jxmHJ1UMO2bzts09Yt7suqrxEGopcEwTuXuUG3Ai8CbwCNAXaAnOruy4f28EHH+xSmGbNcm/d2v3ii93btAmva3OPzGsrvk5bs8b9L39xv/Za9yOOcG/Rwj2UT9zbtnU/5BD35s3db73VfcOGyu8jUiyA+Z7Dd2y1JYgo27QiDJjbaGbNgZ3c/R+1z191QyWIwpStu2xtGpdr29i9cWOYZypbKaNTp1BFNWWKGrqleG1zFZOZpdx9VoUxEP/l7tO2McZtpgRRmOqqF1Nd+vRTGDIkdNVt0ybE0rlzMrGIJC3XBFHpQDngcGAWYexDRQ4kniCkMGVLAqWlyf7F/tprISkMGQIPPgi9eoXpzkuqr4UVKVqVJgh3vy56HFabG5tZB+D3wB7AJmCCu//GzG4iJJ31wLvAMHf/d3TN1cA5wEbgYnf/a23eWyRTxSqu0tIwErxfvzAQ8IQTko5QpDBVNdXGZVVd6O63VHPvcuByd19oZi2BBWY2E5gJXO3u5WY2FrgauNLMugODCdN77AU8bWZd3V1L2cg2qThCfNiwsCb3qFFw8slw221hOVYR2VJVU220jLYS4HygXbSdB3Sv7sbuvtLdF0bPvwCWAu3cfYa7l0enzQHaR89PBh5296/d/X3gHaBPzX8kkS2NHr119dagQaHh+vjjYeRI+NGPNnfJFZGgqiqmGwDMbAbQK/qSx8yuB6bU5E3MrDPQE5hb4dDZwB+j5+0ICSNtWbRPJBY77giPPhpKEjffDB9+CL//PeywQ9KRiRSGXKb77khoL0hbD3TO9Q3MrAVhyvBLfPN04ZjZGEI11KT0riyXb9XFysxGmNl8M5v/ySef5BqGSFaNG4cqpptvDmtgHHEE6NdKJMglQTwAzDOz683sOkIp4P5cbm5mTQnJYVJmt1gzG0qYKfZM39zPdhnQIePy9sCKivd09wnuXuLuJW3bts0lDJEqmcFll4WxEa+8EkZgv/120lGJJK/aBOHuvwCGAf8C/k3odfT/qrvOzAy4G1ia2aBtZscCVwInufu6jEseBwabWTMz2xvYF5hXkx9GZFsMGhTWvfjss5AkXnwx6YhEklXVOIj/ihqbF9bw3ocCQ4DFZrYo2ncNMB5oBswMOYQ57n6euy8xs8nAG4Sqp5HqwST5dsghYfT1wIGhuumBB+C005KOSiQZOU21Uag0klrismYNfPe7oRQxblzo5aSpxaWhyHUkdS5tECJFp00bePrpMMBu9OgwTqK8vPrrRBoSJQiRSmy/fZhefPRo+N3v4IADYPr0Lc/REqjSkClBiFShUSMYOzasRfHWW2Hk9ZRoFFB6Co/evZONUSQuOTVSixS7886Djh1DT6fBg8NSq1Onan1sadhUghDJ0cCB8NJL0Lw53HlnWEZVyUEaMiUIkRr4979hu+1gzz1D6WHEiK3X1hZpKJQgRHKUbnN45BF4991Qepg4EY4+Gr76KunoROqeEoRIjjKnDd9hh9AOcfbZoTvsgAHwj8QX4RWpW0oQIjmqOG24Gdx9N0ybBosXh95MC2s634BIAVOCENlGp5wSRlybbV6lTqQhUIIQqQMHHRSqoHr2DHM3/fSnaryW+k8JQqSO7L57mA126FC47jr4/vdh3brqrxMpVEoQInWoWTO491646aZQ1XTYYbBsWdJRidSOEoRIHTMLs78+8URYeKh3b5hbcbFdkXpACUIkJscfD3PmhJHXhx8ODz6YdEQiNaMEIRKj7t1h3rywENGQIXD11bBpU9JRieRGCUIkZq1bw4wZcO65cOON8K1vwV/+suU5mjZcCpEShEgeNG0apgy//fbN04Y/9FA4Vptpw8eNC9dlUpKRuqYlR0Xy7Omnw3Km69ZBp06wYgX07w/f+Aa0aBG2li03P8/c0vtfeQXOOWfz1B/pJKPpxyUXuS45qvUgRPLsyCPDlBwnnwxvvgm77QbvvQevvQZffAFffpn7vVIp2Hnn8PzRR5UcpG4pQYgkYPlyWLMGfvzjUPV0112bv9w3boT//Ccki7VrN2/ZXj/5JPztb9CkSeheK1KXlCBE8qxidVBp6ZavGzeGnXYKW3X3GT8eLr00PB5zTEgYqVR+fg5p+NRILZJnmdOGQ3icPDnsz1VmkrnllvC4cSMceyzMnBlP3FJ81EgtUg+NGxd6PWW2OTz6KFxwAfzrX/CnP4UShUg2uTZSK0GINCCffhoawZcuDetUDByYdERSiHJNEKpiEmlAWrcOK91961thnYo//znpiKQ+U4IQaWB23TW0Qxx4IJx6aqhuEqkNJQiRBqhVq5AkevWC730vVDeJ1JQShEgDtfPOYQ6oPn1Cj6cpU5KOSOobJQiRBmynneCpp8JssmecAQ8/HM/7aG6ohkkJQqSBa9kyDKA79FA480yYNKnu36N371BKSSeJ2kxAKIVHI6lFikCLFjB9Opx4Ipx1VhhUd9ZZdXf/0lK4554wv1RpKbz0kiYObAiUIESKxI47hm6vJ58M//M/IUkMG1b7+7mHyQb//OewvsULL4R7Pv449OwZVtGT+i22KiYz62BmZWa21MyWmNmoaP+uZjbTzN6OHltF+83MxpvZO2b2mpn1iis2kWLVvHn4Aj/qqDBd+F131ez6r76Cv/4VLroIunQJK+aNHh1Gb3//+7DLLtCvX5iO/IQTtHpefRdnG0Q5cLm7fxPoC4w0s+7AVcAz7r4v8Ez0GuA4YN9oGwHcEWNsIkVrhx3C2Ihjj4Xhw+Gyy7Y8XrFxeflymDAhlDxatw7X3X037L8//O538NFH8Otfhx5T06bBc8+F5VWffDKM5N64Mb8/n9Qhd8/LBvwJOAp4C9gz2rcn8Fb0/E7gjIzz/3teZdvBBx/sIlI7X33l3revO7hffHHYN2uWe5s27rff7j5mjPtBB4Xj4N6pk/vIke7Tp7uvW7flvcaODddmGjo0XHfWWe7l5fn4iSRXwHzP4Xs7L20QZtYZ6AnMBXZ395VRclppZrtFp7UDPs64bFm0b2U+YhQpNs2awezZYXrw8eNh3rxQNdSsGVx4YZh2/DvfgbFj4fjjQ3VSZWtOjB699b777oN99oHrrgtVTffdF+4p9UfsCcLMWgBTgUvc/XOrfFWTbAe2mknQzEYQqqDo2LFjXYUpUpSaNQtVSj16wJw5sP32cNJJISEcc0wYkb0tfvITaNQoLIy0aRPcf39Y3Ejqh1jHQZhZU0JymOTu6cH+q8xsz+j4nsDqaP8yoEPG5e2BFRXv6e4T3L3E3Uvatm0bX/AiReLFF8MssCNHhu6wZ58Ngwdve3JIu/Za+MUv4A9/CF1ry8vr5r71SX0dSBhnLyYD7gaWuvstGYceB4ZGz4cS2ibS+8+KejP1BT5LV0WJSDwyFx66/fbwmDngra5ccw3ceCM89BD88IfFlyTSAwmfeSa8ri8DCeMs7B0KDAEWm9miaN81wI3AZDM7B/gIOC06Nh0YCLwDrAO2oYe2iOSiqtXt6nqQ25VXhuqm0aNDddOkSdC0ad2+RyHasAHWrQuz6x55JOy1F3z5JUydWvgDCWNLEO7+AtnbFQCOyHK+AyPjikdEtpatcTm9TnYcrrgiJIkf/Sj0jfrDHxpmkti0CZ5/PpSYpkyBf/4zVNn16AGvvRYa6xctCoMJGxXwhEcFHJqINESXXx7W0X7kkdDWsWFD0hHVDXdYsCD8fB07woAB8MADYdzIE0+EiRJXrIBLLw0J4rLLQg+yDz5IOvLKKUGISN5demkYXDdtWhiBvX590hHV3ptvhq683bpBSQncdhscfHAoPaxeHarSdtwxTJQ4eXJIjk8+GToEzJsHBxwQRrQX4urP6nAmIokYNSpUr1x88eaG8u22SzqqLY0bFxqSM6vcysrCYkytWoUk8MorYXxIaWmosjv11LCqX6aKbT2pVJjyZMYMmDs3jGh/7DGYOBH23DN/P1+1chlNV6ibRlKL1H+33x5GXJ94YhjdXUjSI8tnzXJfvdp91Cj3Jk02jy7v08f91lvdly+v/Xts3Oj+m9+4b7+9+667uj/8cN3FXxkKaSS1iEhlRo4MJYkLLoBBg0LvnmbNkov4ciPIAAAHxElEQVRn/Xp49114662wlZTA0UeHOaXcQ/vC8OGh/eQb39j290uXoo45JowTGTwYHn0UfvvbMPdVkpQgRCRx558fvijPOy/07Jk9O4zqhlCl8/LL2XtcVaayqqH0fdxh1arNSSBze//9LScY3GOP0DX1o49gxIgwQWHlE0LUXrduYdDi2LFwww3w7LNhUsSBA+v+vXKlRmoRKQjnnht69sydC/37h6nFazKgzH3zmIPu3eG000JpZPFiuP76MP3400+HNbpbtQp1/QMGhPf9v/8LCaBnT7j66tD7aN48+Pe/Q1fcdevCdCHTpoXkFZcmTWDMmPDebdqEKU+GD4cvvojvPatiXohN5zkqKSnx+fPnJx2GiNShK66AX/0qrC2xdi106BCqnMrLQwLYsCH781ymFW/fPvylXnHr2DH7eITMkealpVu/jtPXX4feUTfdFOK77766W4TJzBa4e0m15ylBiEihGTQo/LW+777wrW+Fv6ybNg1b+nnFx2z7nnoqdCkdPjx0L23RomZxVFdVlQ8vvRTaJt57L6wrPmZMGFuxLfHkmiAS74m0LZt6MYk0POmeQz/+8eYeREnepxCsXet+wQWh51Tjxu533BH2Z/ayqgly7MWU+Jf8tmxKECINS8UvvNp+AdbVfQrNjBnh5wD3o4+u/c+Ua4JQI7WIFIyqJg9M4j6F5qij4O23w+jrGTNC768420LUBiEiUo+kG8rPPx/uuKN2Dea5tkGoBCEiUk9k9qL66U/jW78jTQlCRKSeyHfVmaqYRESKjKqYRERkmyhBiIhIVkoQIiKSlRKEiIhkpQQhIiJZ1eteTGb2CfBhjG/RBlgT4/3joJjzo77FXN/iBcUcp07u3ra6k+p1goibmc3PpStYIVHM+VHfYq5v8YJiLgSqYhIRkayUIEREJCsliKpNSDqAWlDM+VHfYq5v8YJiTpzaIEREJCuVIEREJKuiTxBm1sHMysxsqZktMbNRWc4ZYGafmdmiaPtJErFWiOkDM1scxbPVjIUWjDezd8zsNTPrlUScGfF0y/j8FpnZ52Z2SYVzEv+czeweM1ttZq9n7NvVzGaa2dvRY6tKrh0anfO2mQ1NMN6bzOzN6N/9UTPbpZJrq/wdynPM15vZ8ox/+4GVXHusmb0V/V5flXDMf8yI9wMzW1TJtYl8znUil2XnGvIG7An0ip63BP4OdK9wzgDgz0nHWiGmD4A2VRwfCDwJGNAXmJt0zBmxNQb+QeiLXVCfM9Af6AW8nrFvHHBV9PwqYGyW63YF3oseW0XPWyUU79FAk+j52Gzx5vI7lOeYrwd+lMPvzbvAPsB2wKsV/6/mM+YKx28GflJIn3NdbEVfgnD3le6+MHr+BbAUaJdsVHXiZOD3HswBdjGzPZMOKnIE8K67xznIsVbc/TngnxV2nwzcHz2/H/hulkuPAWa6+z/d/V/ATODY2AKNZIvX3We4e3n0cg7QPu44aqKSzzgXfYB33P09d18PPEz4t4ldVTGbmQGnAw/lI5Z8KvoEkcnMOgM9gblZDh9iZq+a2ZNmtn9eA8vOgRlmtsDMRmQ53g74OOP1Mgon8Q2m8v9MhfY5A+zu7ish/EEB7JblnEL9vM8mlCSzqe53KN8ujKrF7qmkGq9QP+PDgFXu/nYlxwvtc86ZEkTEzFoAU4FL3P3zCocXEqpDDgRuAx7Ld3xZHOruvYDjgJFm1r/CcctyTeJd1sxsO+AkYEqWw4X4Oeeq4D5vMxsDlAOTKjmlut+hfLoD6AIcBKwkVNlUVHCfceQMqi49FNLnXCNKEICZNSUkh0nuPq3icXf/3N3XRs+nA03NrE2ew6wY04rocTXwKKH4nWkZ0CHjdXtgRX6iq9JxwEJ3X1XxQCF+zpFV6eq56HF1lnMK6vOOGslPAM70qCK8ohx+h/LG3Ve5+0Z33wRMrCSWgvqMAcysCXAq8MfKzimkz7mmij5BRPWHdwNL3f2WSs7ZIzoPM+tD+Nw+zV+UW8Wzo5m1TD8nNEq+XuG0x4Gzot5MfYHP0tUkCav0r61C+5wzPA6keyUNBf6U5Zy/AkebWauoeuToaF/emdmxwJXASe6+rpJzcvkdypsK7WOnVBLLy8C+ZrZ3VBIdTPi3SdKRwJvuvizbwUL7nGss6VbypDegH6GY+hqwKNoGAucB50XnXAgsIfSamAN8J+GY94lieTWKa0y0PzNmA35L6PWxGCgpgM+6OeELf+eMfQX1OROS10pgA+Ev1nOA1sAzwNvR467RuSXAXRnXng28E23DEoz3HUJdffr3+XfRuXsB06v6HUow5gei39PXCF/6e1aMOXo9kNDT8N2kY47235f+/c04tyA+57rYNJJaRESyKvoqJhERyU4JQkREslKCEBGRrJQgREQkKyUIERHJSglCpI6ZWefMWT9F6islCBERyUoJQiRGZraPmb1iZr2TjkWkppQgRGJiZt0Ic3wNc/eXk45HpKaaJB2ASAPVljBn0yB3X5J0MCK1oRKESDw+I8yHdGjSgYjUlkoQIvFYT1h57q9mttbd/5B0QCI1pQQhEhN3/4+ZnQDMNLP/uHu2acJFCpZmcxURkazUBiEiIlkpQYiISFZKECIikpUShIiIZKUEISIiWSlBiIhIVkoQIiKSlRKEiIhk9f8BbzAUgdU9lfMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2243dd29a58>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "K=range(2,20)\n",
    "calinski_harabaz_scores=[]\n",
    "for k in K:\n",
    "    kmeans=KMeans(n_clusters=k)\n",
    "    kmeans.fit(new_train_df)\n",
    "    calinski_harabaz_scores.append(metrics.calinski_harabaz_score(new_train_df, kmeans.predict(new_train_df)))\n",
    "plt.plot(K,calinski_harabaz_scores,'bx-')\n",
    "plt.xlabel('k')\n",
    "plt.ylabel(u'distortion degree')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "kmeans=KMeans(n_clusters=12)\n",
    "kmeans.fit(new_train_df)\n",
    "new_train_df['cluster_factor']=kmeans.predict(new_train_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7804749461033647, 0.042362860092948845)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier, new_train_df, label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3 多项式特征\n",
    "简单来说就这样的过程：$[a,b]->[1,a,b,a^2,b^2,ab]$，通常用于构造“是/否”这样的特征，比如$a=0/1,b=0/1$，那么$ab=1$就表示$a=1$且$b=1$的情况   \n",
    "\n",
    "**特别注意：构造多项式特征慎用，它以$O(n^2)$增涨特征量，如果原始有1000个特征，变换后会有100W个特征，建议单独对某一特征子集使用**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "poly=PolynomialFeatures(degree=2,include_bias=False,interaction_only=False)#\n",
    "poly_fea_np=poly.fit_transform(train_df)\n",
    "poly_fea_df=pd.DataFrame(poly_fea_np,columns=poly.get_feature_names())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7790340389472006, 0.033251719990077054)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier, poly_fea_df, label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.4 自动构建组合特征\n",
    "比较流行的一种方式是gbdt+lr,即利用gbdt探索不错的特征空间，然后用lr对这些特征空间张成one-hot特征进行拟合；  \n",
    "![avatar](./source/gbdt_lr.png)\n",
    "参考：https://www.cnblogs.com/wkang/p/9657032.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7725114798293671, 0.01960145339940876)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "n_trees=100\n",
    "tree_depth=2#树的深度不必太深\n",
    "kfold= KFold(n_splits=5,shuffle=True)\n",
    "scores=[]\n",
    "for train_index,test_index in kfold.split(new_train_df,label):\n",
    "    X_train=new_train_df.loc[train_index]\n",
    "    y_train=label[train_index]\n",
    "    X_test=new_train_df.loc[test_index]\n",
    "    y_test=label[test_index]\n",
    "    \n",
    "    gbm1 = GradientBoostingClassifier(n_estimators=n_trees,max_depth=tree_depth)\n",
    "    gbm1.fit(X_train, y_train)\n",
    "    train_new_feature = gbm1.apply(X_train)\n",
    "    train_new_feature = train_new_feature.reshape(-1, n_trees)\n",
    "\n",
    "    enc = OneHotEncoder()\n",
    "\n",
    "    enc.fit(train_new_feature)\n",
    "\n",
    "    # # # 每一个属性的最大取值数目\n",
    "    # # print('每一个特征的最大取值数目:', enc.n_values_)\n",
    "    # # print('所有特征的取值数目总和:', enc.n_values_.sum())\n",
    "\n",
    "    train_new_feature2 = np.array(enc.transform(train_new_feature).toarray())\n",
    "\n",
    "    #训练lr\n",
    "    lr=LogisticRegression()\n",
    "    lr.fit(train_new_feature2,y_train)\n",
    "    #测试\n",
    "    test_new_feature = gbm1.apply(X_test)\n",
    "    test_new_feature = test_new_feature.reshape(-1, n_trees)\n",
    "    test_new_feature2 = np.array(enc.transform(test_new_feature).toarray())\n",
    "\n",
    "    y_predict=lr.predict(test_new_feature2)\n",
    "    f1_score=metrics.f1_score(y_test,y_predict)\n",
    "    scores.append(f1_score)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 二. 特征选择\n",
    "特征选择主要有两个方向：   \n",
    "\n",
    "（1）基于统计指标：方差、相关性、gini、info gain、chi2，统计指标其实在一开始的数据清洗阶段也有用到    \n",
    "\n",
    "（2）基于模型指标：RFE递归删减特征、训练基模型，选择权值系数较高的特征  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 删除低方差特征\n",
    "在我们造的特征中可能会产生一些低方差特征，这类特征往往倾斜严重"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(891, 50)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectFromModel,VarianceThreshold\n",
    "VarianceThreshold(threshold=0.01).fit_transform(poly_fea_df).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7866156425794545, 0.027746067690248344)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier, VarianceThreshold(threshold=0.01).fit_transform(poly_fea_df), label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 选择高相关性特征\n",
    "变相排除低相关性特征"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Survived    1.000000\n",
       "x2 x8       0.548295\n",
       "x1          0.543351\n",
       "x2          0.543351\n",
       "x1^2        0.543351\n",
       "Name: Survived, dtype: float64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import copy\n",
    "copy_df=copy.deepcopy(poly_fea_df)\n",
    "copy_df['Survived']=label\n",
    "copy_df.corr()['Survived'].abs().sort_values(ascending=False).head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#选择相关性>0.2的因子建模，注意要去掉Survived\n",
    "highly_correlated_features = copy_df.columns[copy_df.corr()['Survived'].abs() > 0.1]\n",
    "highly_correlated_features = highly_correlated_features.drop('Survived')\n",
    "high_corr_features_df=copy_df[highly_correlated_features]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7905768103351534, 0.03280111455743408)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier, high_corr_features_df, label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 选择高gini指数特征\n",
    "要计算gini指数，可以通过训练决策树得到"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature</th>\n",
       "      <th>importance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>x1 x3</td>\n",
       "      <td>0.347396</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>x0</td>\n",
       "      <td>0.086186</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>x0 x6</td>\n",
       "      <td>0.067206</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>x7</td>\n",
       "      <td>0.056080</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>x3 x6</td>\n",
       "      <td>0.049074</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   feature  importance\n",
       "20   x1 x3    0.347396\n",
       "0       x0    0.086186\n",
       "15   x0 x6    0.067206\n",
       "7       x7    0.056080\n",
       "36   x3 x6    0.049074"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "tree = DecisionTreeClassifier()#如果要用信息增益，设置criterion='entropy'\n",
    "tree.fit(poly_fea_df,label)\n",
    "importances = pd.DataFrame({ 'feature':poly_fea_df.columns,'importance': tree.feature_importances_}).sort_values('importance', ascending=False)\n",
    "importances.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7810221130326891, 0.03470329254309837)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#选择top因子建模\n",
    "select_features=importances['feature'].tolist()[:50]\n",
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier, poly_fea_df[select_features], label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 选择高chi2特征"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7882105223722208, 0.036066492211802935)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.feature_selection import chi2\n",
    "#选择前50个特征\n",
    "top_50_feature_df=SelectKBest(chi2, k=50).fit_transform(poly_fea_df, label)\n",
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier, top_50_feature_df, label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### RFE递归消除\n",
    "就是一个一个删掉去试，一般不用，跑的太慢了...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.feature_selection import RFE\n",
    "# rfe_df=RFE(estimator=GradientBoostingClassifier(), n_features_to_select=50).fit_transform(poly_fea_df, label)\n",
    "# classifier=GradientBoostingClassifier()\n",
    "# scores = cross_val_score(classifier, rfe_df, labels, scoring='f1', cv = 5)\n",
    "# np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 基于模型选特征\n",
    "其实这里和gini系数的选择一样，通过训练一个模型来选择特征最优特征，然后再去训练一个模型，只是这里选择特征用的模型与训练用的模型一样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature</th>\n",
       "      <th>importance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>x1 x3</td>\n",
       "      <td>0.456122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>x0^2</td>\n",
       "      <td>0.074019</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>x0 x3</td>\n",
       "      <td>0.047668</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>52</th>\n",
       "      <td>x7 x8</td>\n",
       "      <td>0.044320</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>x6 x8</td>\n",
       "      <td>0.042022</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   feature  importance\n",
       "20   x1 x3    0.456122\n",
       "9     x0^2    0.074019\n",
       "12   x0 x3    0.047668\n",
       "52   x7 x8    0.044320\n",
       "50   x6 x8    0.042022"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gbdt = GradientBoostingClassifier()\n",
    "gbdt.fit(poly_fea_df,label)\n",
    "importances = pd.DataFrame({ 'feature':poly_fea_df.columns,'importance': gbdt.feature_importances_}).sort_values('importance', ascending=False)\n",
    "importances.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7827012697429128, 0.035156370587767695)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#选择top因子建模\n",
    "select_features=importances['feature'].tolist()[:50]\n",
    "features_select_top_50_df=poly_fea_df[select_features]\n",
    "#gbdt\n",
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier,features_select_top_50_df,label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SelectFromModel自动选择最优特征"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7637325156867544, 0.05080842842696327)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kfold= KFold(n_splits=5,random_state=42,shuffle=True)\n",
    "scores=[]\n",
    "top_nums=[]\n",
    "for train_index,test_index in kfold.split(poly_fea_df,label):\n",
    "    X_train=poly_fea_df.loc[train_index]\n",
    "    y_train=label[train_index]\n",
    "    X_test=poly_fea_df.loc[test_index]\n",
    "    y_test=label[test_index]\n",
    "    \n",
    "    select_feature_model = SelectFromModel(GradientBoostingClassifier())\n",
    "    X_new_train=select_feature_model.fit_transform(X_train,y_train)\n",
    "    \n",
    "    X_new_test=select_feature_model.transform(X_test)\n",
    "    \n",
    "    _,top_num=X_new_test.shape\n",
    "    top_nums.append(top_num)\n",
    "    \n",
    "    gbdt=GradientBoostingClassifier()\n",
    "    gbdt.fit(X_new_train,y_train)\n",
    "    y_predict=gbdt.predict(X_new_test)\n",
    "    f1_score=metrics.f1_score(y_test,y_predict)\n",
    "    scores.append(f1_score)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 三.特征转换\n",
    "不同于特征选择，特征转换是将原始特征空间映射到了一个新的低维（往往是）空间中，梳理了如下这些方法：   \n",
    "\n",
    "（1）pca:主成分分析；   \n",
    "\n",
    "（2）lda:线性判别分析；   \n",
    "\n",
    "（3）lle:局部线性嵌入；   \n",
    "\n",
    "（4）ae:自编码；   \n",
    "\n",
    "（5）vae:变分自编码；"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### pca\n",
    "pca是一种无监督的线性降维方式，它构建了一个新的正交坐标系，相应的坐标轴分别叫“第一主成分”，“第二主成分”...，且数据在“第一主成分”坐标轴上**方差**最大，“第二主成分”其次，...通常可以只取前n个主成分，将方差较小的主成分理解为**噪声**；  \n",
    "![avatar](./source/pca示例.png)\n",
    "更多：https://blog.csdn.net/program_developer/article/details/80632779 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "standard_df=StandardScaler().fit_transform(poly_fea_df)\n",
    "X_pca=PCA(n_components=20).fit_transform(standard_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7570897942864615, 0.05234462942327912)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier,X_pca, label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2244009a9b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 前两维的效果\n",
    "plt.scatter(X_pca[:, 0], X_pca[:, 1],marker='o',c=label)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### lda\n",
    "lda是一种线性的有监督降维方式，与pca的最大化方差的目标不同，它的目标是找到这样的新坐标轴：**同类样例的投影尽可能近，异类样例的投影点尽可能远**；  \n",
    "更多：https://blog.csdn.net/weixin_40604987/article/details/79615968"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7230947045846136, 0.03832196912050019)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.discriminant_analysis  import LinearDiscriminantAnalysis\n",
    "kfold= KFold(n_splits=5,random_state=42,shuffle=True)\n",
    "scores=[]\n",
    "for train_index,test_index in kfold.split(poly_fea_df,label):\n",
    "    X_train=poly_fea_df.loc[train_index]\n",
    "    y_train=label.loc[train_index]\n",
    "    X_test=poly_fea_df.loc[test_index]\n",
    "    y_test=label.loc[test_index]\n",
    "    \n",
    "    lda=LinearDiscriminantAnalysis(n_components=20)\n",
    "    lda.fit(X_train, y_train)\n",
    "    \n",
    "    X_new_train=lda.transform(X_train)\n",
    "    X_new_test=lda.transform(X_test)\n",
    "    \n",
    "    gbdt=GradientBoostingClassifier()\n",
    "    gbdt.fit(X_new_train,y_train)\n",
    "    y_predict=gbdt.predict(X_new_test)\n",
    "    f1_score=metrics.f1_score(y_test,y_predict)\n",
    "    scores.append(f1_score)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x224400be208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X_new_train[:, 0], X_new_train[:, 0],marker='o',c=y_train)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### lle-局部线性嵌入（LocallyLinearEmbedding）\n",
    "降维时保持样本局部的线性特征\n",
    "![avatar](./source/lle示例.jpg)\n",
    "更多：https://www.cnblogs.com/pinard/p/6266408.html?utm_source=itdadao&utm_medium=referral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5623881209232492, 0.0636799703332207)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.manifold import LocallyLinearEmbedding\n",
    "X_lle=LocallyLinearEmbedding(n_components=20).fit_transform(poly_fea_df)\n",
    "classifier=GradientBoostingClassifier()\n",
    "scores = cross_val_score(classifier,X_lle, label, scoring='f1', cv = 5)\n",
    "np.mean(scores),np.std(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x22440092400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X_lle[:, 0], X_lle[:, 1],marker='o',c=label)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ae-自编码  \n",
    "可以把它看做一个压缩和解压的过程，如下，通过encoder把一个高维的数据压缩为低维的数据，再通过decoder将低维数据还原为高维的数据，这样这个低维的数据可以看做高维数据的一种“不失真”表示，编码器和解码器通常使用神经网络...   \n",
    "\n",
    "![avatar](./source/ae.png)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from keras.models import Model\n",
    "# from keras.layers import *\n",
    "\n",
    "# #定义网络结构\n",
    "# epochs=200\n",
    "# batch_size=128\n",
    "# input_dim=poly_fea_df.shape[1]\n",
    "\n",
    "# input_layer=Input(shape=(input_dim,))\n",
    "# encode_layer=Dense(2,activation='relu',name='encoder')(input_layer)\n",
    "# decode_layer=Dense(input_dim,activation='tanh')(encode_layer)\n",
    "\n",
    "# model=Model(inputs=input_layer,outputs=decode_layer)\n",
    "# #获取encode_layer层的输出\n",
    "# encode_layer_model = Model(inputs=model.input,outputs=model.get_layer('encoder').output)\n",
    "# model.compile('adam',loss='mse')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#训练模型\n",
    "# model.fit(poly_fea_df[:500],poly_fea_df[:500],batch_size=batch_size,epochs=epochs,validation_data=[poly_fea_df[500:],poly_fea_df[500:]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  vae-变分自编码\n",
    "会让中间层的编码数据更加趋近于高斯分布  \n",
    "\n",
    "参考：https://blog.csdn.net/weixin_41923961/article/details/81586082"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
